﻿#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>

using namespace std;

//int main()
//{
//	/*int a = 1;
//	int& b = a;
//	int& c = b;
//
//	cout << a << endl;
//	cout << b << endl;
//	cout << c << endl;*/
//
//
//	int& a;
//	return 0;
//}

//int main()
//{
//	int a = 1;
//	int c = 2;
//	int& b=a;
//	int& b = c;
//	return 0;
//}
//void TestConstRef()
//{
//	const int a = 10;
//	//int& ra = a;   // 编译出错，const int不能修改变量
//					 //	int&可以修改变量，属于权限的放大
//
//	const int& ra = a;//编译不出错，const int不能修改变量
//					  //const int&不能修改变量，属于权限的平移
//	
//	int m = 0;		 //编译不出错，
//	const int& n = m;// const不能修改变量，属于权限的缩小
//
//
//	double d = 12.34;
//	//int& rd = d; // 该语句编译时会出错，类型发生截断，生成临时变量，具有常属性
//	const int& rd = d;//用const修饰之后rd不能改变，属于权限的平移
//}
//int main()
//{
//	//int x = 0;
//	//	int& y = x;
//	//	const int& z = x;
//	//	++x;
//	//	//++z;
//	//
//	//	const int& m = 10;
//	//
//	//	double dd = 1.11;
//	//	int ii = dd;
//	//
//	//	const int& rii = dd;
//
//	return 0;
//}

//#include <time.h>
//struct A { int a[10000]; };
//void TestFunc1(A a) {}
//void TestFunc2(A& a) {}
//void TestRefAndValue()
//{
//	A a;
//	// 以值作为函数参数
//	size_t begin1 = clock();
//	for (size_t i = 0; i < 10000; ++i)
//		TestFunc1(a);
//	size_t end1 = clock();
//	// 以引用作为函数参数
//	size_t begin2 = clock();
//	for (size_t i = 0; i < 10000; ++i)
//		TestFunc2(a);
//	size_t end2 = clock();
//	// 分别计算两个函数运行结束后的时间
//	cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
//	cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
//}

//
//#include <time.h>
//struct A { int a[10000]; };
//A a;
//// 值返回
//A TestFunc1() { return a; }
//// 引用返回
//A& TestFunc2() { return a; }
//void TestReturnByRefOrValue()
//{
//	// 以值作为函数的返回值类型
//	size_t begin1 = clock();
//	for (size_t i = 0; i < 100000; ++i)
//		TestFunc1();
//	size_t end1 = clock();
//	// 以引用作为函数的返回值类型
//	size_t begin2 = clock();
//	for (size_t i = 0; i < 100000; ++i)
//		TestFunc2();
//	size_t end2 = clock();
//	// 计算两个函数运算完成之后的时间
//	cout << "TestFunc1 time:" << end1 - begin1 << endl;
//	cout << "TestFunc2 time:" << end2 - begin2 << endl;
//}

//int main()
//{
//	int a = 10;
//
//	int& ra = a;
//	ra = 20;
//
//	int* pa = &a;
//	*pa = 20;
//
//	return 0;
//}
//
//int main()
//{
//	//TestRefAndValue();
//	TestReturnByRefOrValue();
//	return 0;
//}

// main.cpp
//#include "F.h"
//int main()
//{
//	f(10);
//	return 0;
//}

//inline int Add(int x, int y)
//{
//	return x + y;
//}
//
//int main()
//{
//	int sum = 0;
//	sum=Add(3, 5);
//	return 0;
//}
//
//#include<map>
//#include<string>
//#include<vector>
//
//int main()
//{
//	int a = 0;
//	int b = a;
//	auto c = a; // 根据右边的表达式自动推导c的类型
//	auto d = 1 + 1.11; // 根据右边的表达式自动推导d的类型
//	cout << typeid(c).name() << endl;
//	cout << typeid(d).name() << endl;
//
//	vector<int> v;
//
//	// 类型很长
//	//vector<int>::iterator it = v.begin();
//	// 等价于
//	auto it = v.begin();
//
//	std::map<std::string, std::string> dict;
//	//std::map<std::string, std::string>::iterator dit = dict.begin();
//	// 等价于
//	auto dit = dict.begin();
//
//	return 0;
//}

//int main()
//{
//	int x = 10;
//	auto a = &x;
//	auto* b = &x;
//	auto& c = x;
//	cout << typeid(a).name() << endl;
//	cout << typeid(b).name() << endl;
//	cout << typeid(c).name() << endl;
//	*a = 20;
//	*b = 30;
//	c = 40;
//	return 0;
//}

//void TestFor()
//{
//	int arr[] = { 1, 2, 3, 4, 5 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	for (int i = 0; i < sz; ++i)
//		arr[i] *= 2;
//
//	for (int* p = arr; p < arr+sz; ++p)
//		cout << *p << endl;
//}
//
//void TestFor()
//{
//	int array[] = { 1, 2, 3, 4, 5 };
//	for (auto& e : array)
//		e *= 2;
//
//	for (auto e : array)
//		cout << e << endl;
//}

void f(int)
{
	cout << "f(int)" << endl;
}
void f(int*)
{
	cout << "f(int*)" << endl;
}
int main()
{
	f(0);
	f(NULL);
	f((int*)NULL);
	return 0;
}


//int main()
//{
//	TestFor();
//	return 0;
//}